{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.306961\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "没有经过训练的softmax，理论上预测每个标签的概率都是1/10，因此loss理论值为-log(0.1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -1.252900 analytic: -1.252900, relative error: 4.126504e-08\n",
      "numerical: -0.081440 analytic: -0.081440, relative error: 1.990930e-07\n",
      "numerical: -0.714696 analytic: -0.714696, relative error: 2.582723e-08\n",
      "numerical: 2.516606 analytic: 2.516606, relative error: 4.227434e-09\n",
      "numerical: -1.471872 analytic: -1.471872, relative error: 2.695143e-08\n",
      "numerical: -1.946665 analytic: -1.946665, relative error: 7.666402e-09\n",
      "numerical: -1.119519 analytic: -1.119519, relative error: 2.404791e-09\n",
      "numerical: 0.122622 analytic: 0.122622, relative error: 3.108684e-08\n",
      "numerical: 0.703022 analytic: 0.703022, relative error: 1.842454e-07\n",
      "numerical: -1.484659 analytic: -1.484659, relative error: 1.025508e-08\n",
      "numerical: -0.674509 analytic: -0.674509, relative error: 2.215566e-08\n",
      "numerical: 1.779646 analytic: 1.779646, relative error: 4.707377e-09\n",
      "numerical: -0.913333 analytic: -0.913333, relative error: 2.946265e-08\n",
      "numerical: 2.878087 analytic: 2.878087, relative error: 5.396504e-09\n",
      "numerical: 1.199030 analytic: 1.199030, relative error: 1.935636e-08\n",
      "numerical: 2.078154 analytic: 2.078153, relative error: 3.439587e-08\n",
      "numerical: -0.945330 analytic: -0.945330, relative error: 2.892020e-08\n",
      "numerical: -2.521563 analytic: -2.521564, relative error: 2.981802e-08\n",
      "numerical: -0.932580 analytic: -0.932580, relative error: 1.323790e-08\n",
      "numerical: 1.098381 analytic: 1.098381, relative error: 4.310281e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.306961e+00 computed in 0.118479s\n",
      "vectorized loss: 2.306961e+00 computed in 0.001995s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 308.730346\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.31\n",
      "0.292\n",
      "0.276\n",
      "0.251\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.291918 val accuracy: 0.310000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.298878 val accuracy: 0.292000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.268898 val accuracy: 0.276000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.222755 val accuracy: 0.251000\n",
      "best validation accuracy achieved during cross-validation: 0.310000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        loss_hist = softmax.train(X_train, y_train, learning_rate=lr, reg=rs,\n",
    "                      num_iters=1500, verbose=False)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        \n",
    "        y_train_acc = np.mean(y_train == y_train_pred)\n",
    "        y_val_acc = np.mean(y_val == y_val_pred)\n",
    "        print(y_val_acc)\n",
    "        \n",
    "        results[(lr, rs)] = (y_train_acc, y_val_acc)\n",
    "        if best_val < y_val_acc:\n",
    "            best_val = y_val_acc\n",
    "            best_softmax = softmax\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.305000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "正确\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n",
    "若分类正确，SVM loss可能为0（当正确标签的值和每个不正确的标签值得差都为0时），但softmax操作使得交叉熵无论在什么时候都不能为0(exp函数总大于0)。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
